home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / digsby / blobs.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  11.5 KB  |  338 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from digsby.abstract_blob import AbstractBlob
  6. import cPickle
  7. from pyxmpp.utils import to_utf8
  8. from copy import deepcopy
  9. from util import Storage
  10. from logging import getLogger
  11. log = getLogger('blobs')
  12. info = log.info
  13. from util.observe import ObservableDict, ObservableList
  14. from struct import pack, unpack
  15. import struct
  16. from os.path import join as pathjoin
  17. from zlib import compress, decompress
  18. import util
  19. import syck
  20. import prefs
  21. from common.notifications import default_notifications
  22. DIGSBY_PREFS_NS = 'digsby:prefs'
  23. DIGSBY_DEFAULT_PREFS_NS = 'digsby:defaultprefs'
  24. DIGSBY_ICON_NS = 'digsby:icon'
  25. DIGSBY_EVENTS_NS = 'digsby:events'
  26. DIGSBY_STATUS_NS = 'digsby:status'
  27. DIGSBY_BUDDYLIST_NS = 'digsby:blist'
  28. DIGSBY_PROFILE_NS = 'digsby:profile'
  29.  
  30. def to_primitive(thing):
  31.     if isinstance(thing, ObservableDict):
  32.         return dict(thing)
  33.     elif isinstance(thing, ObservableList):
  34.         return list(thing)
  35.     
  36.     return thing
  37.  
  38.  
  39. def maybe_copy(thing):
  40.     if isinstance(thing, (dict, list)):
  41.         return deepcopy(thing)
  42.     
  43.     return thing
  44.  
  45.  
  46. class NetData(AbstractBlob):
  47.     timeout = 300
  48.     
  49.     def pack(cls, data):
  50.         return cPickle.dumps(data)
  51.  
  52.     pack = classmethod(pack)
  53.     
  54.     def unpack(cls, data):
  55.         return cPickle.loads(data)
  56.  
  57.     unpack = classmethod(unpack)
  58.     
  59.     def set_data(self, data):
  60.         
  61.         try:
  62.             return AbstractBlob.set_data(self, self.pack(data))
  63.         except:
  64.             import sys
  65.             print >>sys.stderr, 'Error pickling %r: %s' % (self, repr(data)[:200])
  66.             print >>sys.stderr, '  %s' % type(data)
  67.             raise 
  68.  
  69.  
  70.     
  71.     def get_data(self):
  72.         
  73.         try:
  74.             retval = self.unpack(AbstractBlob.get_data(self))
  75.             return retval
  76.         except Exception:
  77.             e = None
  78.             import traceback
  79.             traceback.print_exc()
  80.             log.error('Could not unpickle %s', type(self).__name__)
  81.             self.set_data(to_primitive(self.fallback()))
  82.             return self.get_data()
  83.  
  84.  
  85.     
  86.     def del_data(self):
  87.         self._data = None
  88.  
  89.     data = property(get_data, set_data, del_data)
  90.     
  91.     def fallback(self):
  92.         return list()
  93.  
  94.  
  95.  
  96. class SerializableNetData(NetData):
  97.     __VERSION = 2
  98.     
  99.     def pack(cls, data):
  100.         profile = profile
  101.         import common
  102.         if not profile.blobs3:
  103.             d = serialize(data)
  104.             d = NetData.pack(d)
  105.             d = compress(d)
  106.             v = cls._SerializableNetData__VERSION
  107.         else:
  108.             pydumps = pydumps
  109.             import util.json
  110.             d = pydumps(data).encode('z')
  111.             v = cls._SerializableNetData__VERSION + 1
  112.         log.info('packing version %d of %s', v, cls.__name__)
  113.         return pack('!I', v) + d
  114.  
  115.     pack = classmethod(pack)
  116.     
  117.     def unpack(cls, data):
  118.         (version,) = unpack('!I', data[:4])
  119.         if version not in (1, 2, 3):
  120.             log.info('unpacking version %d of %s', version, cls.__name__)
  121.             data = pack('I', 1) + data
  122.             version = 1
  123.         
  124.         if version == 1:
  125.             log.info('unpacking version %d of %s', version, cls.__name__)
  126.             data = data[4:]
  127.             
  128.             try:
  129.                 data = data.decode('z')
  130.             except Exception:
  131.                 pass
  132.             except:
  133.                 None<EXCEPTION MATCH>Exception
  134.             
  135.  
  136.         None<EXCEPTION MATCH>Exception
  137.         if version == 2:
  138.             log.info('unpacking version %d of %s', version, cls.__name__)
  139.             data = data[4:]
  140.             data = data.decode('z')
  141.         
  142.         if version != 3:
  143.             d = NetData.unpack(data)
  144.             if isinstance(d, (SerializedDict, SerializedSet)):
  145.                 return unserialize(d)
  146.             elif isinstance(d, cls.basetype):
  147.                 return d
  148.             else:
  149.                 return cls.basetype(d)
  150.         
  151.         if version == 3:
  152.             log.info('unpacking version %d of %s', version, cls.__name__)
  153.             profile = profile
  154.             import common
  155.             profile = profile()
  156.             profile.blobs3 = True
  157.             pyloads = pyloads
  158.             import util.json
  159.             return pyloads(data[4:].decode('z'))
  160.         
  161.  
  162.     unpack = classmethod(unpack)
  163.  
  164.  
  165. class ODictNetData(NetData):
  166.     
  167.     fallback = lambda self: ObservableDict()
  168.     basetype = dict
  169.  
  170.  
  171. class Prefs(ODictNetData, SerializableNetData):
  172.     xml_element_namespace = DIGSBY_PREFS_NS
  173.  
  174.  
  175. class DefaultPrefs(NetData):
  176.     xml_element_namespace = DIGSBY_DEFAULT_PREFS_NS
  177.     diskdata = None
  178.     
  179.     def complete_xml_element(self, xmlnode, _unused):
  180.         None if self.tstamp is not None else None
  181.  
  182.     
  183.     def set_data(self, data):
  184.         pass
  185.  
  186.     
  187.     def get_data(self):
  188.         if self.diskdata is None:
  189.             defaults = prefs.defaultprefs()
  190.             self.diskdata = defaults
  191.         
  192.         return self.diskdata
  193.  
  194.     
  195.     def del_data(self):
  196.         pass
  197.  
  198.     data = property(get_data, set_data, del_data)
  199.  
  200.  
  201. class BuddyList(ODictNetData, SerializableNetData):
  202.     xml_element_namespace = DIGSBY_BUDDYLIST_NS
  203.  
  204.  
  205. class Statuses(SerializableNetData):
  206.     xml_element_namespace = DIGSBY_STATUS_NS
  207.     
  208.     fallback = lambda self: ObservableList()
  209.     basetype = list
  210.     
  211.     def pack(cls, data):
  212.         profile = profile
  213.         import common
  214.         if not profile.blobs3:
  215.             return NetData.pack(data)
  216.         else:
  217.             return SerializableNetData.pack(data)
  218.  
  219.     pack = classmethod(pack)
  220.  
  221.  
  222. class Profile(NetData):
  223.     xml_element_namespace = DIGSBY_PROFILE_NS
  224.     
  225.     fallback = lambda self: ''
  226.  
  227.  
  228. class Icon(NetData):
  229.     xml_element_namespace = DIGSBY_ICON_NS
  230.     
  231.     fallback = lambda self: ''
  232.     
  233.     def pack(cls, data):
  234.         return data
  235.  
  236.     pack = classmethod(pack)
  237.     
  238.     def unpack(cls, data):
  239.         return data
  240.  
  241.     unpack = classmethod(unpack)
  242.  
  243.  
  244. class Notifications(ODictNetData, SerializableNetData):
  245.     xml_element_namespace = DIGSBY_EVENTS_NS
  246.     
  247.     fallback = lambda self: deepcopy(default_notifications)
  248.  
  249.  
  250. def load_cache_from_data_disk(name, data):
  251.     StringIO = StringIO
  252.     import StringIO
  253.     f = StringIO(data)
  254.     
  255.     try:
  256.         plen = struct.unpack('!H', f.read(2))[0]
  257.         tstamp = f.read(plen)
  258.         data = f.read()
  259.     except IOError:
  260.         tstamp = '0001-01-01 00:00:00'
  261.         data = None
  262.  
  263.     return name_to_obj[name](tstamp, rawdata = data)
  264.  
  265.  
  266. def load_cache_from_data_db(name, data):
  267.     tstamp = '0001-01-01 00:00:00'
  268.     return name_to_obj[name](tstamp, rawdata = data)
  269.  
  270.  
  271. class SerializedDict(list):
  272.     
  273.     def __init__(self, dict_):
  274.         self[:] = sorted(dict_.iteritems())
  275.  
  276.  
  277.  
  278. class SerializedSet(list):
  279.     
  280.     def __init__(self, set_):
  281.         self[:] = sorted(set_)
  282.  
  283.  
  284. PrimitiveTypes = frozenset((int, bool, float, long, str, unicode, type(None), type))
  285.  
  286. def serialize(thing):
  287.     t = type(thing)
  288.     if t in PrimitiveTypes:
  289.         return thing
  290.     elif t is tuple:
  291.         return tuple((lambda .0: for foo in .0:
  292. serialize(foo))(thing))
  293.     elif t is list:
  294.         return list((lambda .0: for foo in .0:
  295. serialize(foo))(thing))
  296.     elif t is dict:
  297.         bar = SerializedDict(thing)
  298.         bar[:] = [ serialize(foo) for foo in bar ]
  299.         return bar
  300.     elif t is set:
  301.         bar = SerializedSet(thing)
  302.         bar[:] = [ serialize(foo) for foo in bar ]
  303.         return bar
  304.     
  305.  
  306.  
  307. def unserialize(thing):
  308.     t = type(thing)
  309.     if t is SerializedDict:
  310.         return dict((lambda .0: for foo in .0:
  311. unserialize(foo))(thing))
  312.     elif t is SerializedSet:
  313.         return set((lambda .0: for foo in .0:
  314. unserialize(foo))(thing))
  315.     elif t is tuple:
  316.         return tuple((lambda .0: for foo in .0:
  317. unserialize(foo))(thing))
  318.     elif t is list:
  319.         return list((lambda .0: for foo in .0:
  320. unserialize(foo))(thing))
  321.     elif t in PrimitiveTypes:
  322.         return thing
  323.     
  324.  
  325. ns_to_obj = {
  326.     DIGSBY_PREFS_NS: Prefs,
  327.     DIGSBY_ICON_NS: Icon,
  328.     DIGSBY_EVENTS_NS: Notifications,
  329.     DIGSBY_STATUS_NS: Statuses,
  330.     DIGSBY_BUDDYLIST_NS: BuddyList,
  331.     DIGSBY_PROFILE_NS: Profile }
  332. name_to_ns = dict((lambda .0: for key, value in .0:
  333. (value.__name__.lower(), key))(ns_to_obj.iteritems()))
  334. name_to_obj = dict((lambda .0: for name in .0:
  335. (name, ns_to_obj[name_to_ns[name]]))(name_to_ns))
  336. from util import dictreverse
  337. ns_to_name = dictreverse(name_to_ns)
  338.